/**
*
*!!重要规则,子的原点要和父的原点重合?
*
*Group3D也要storeCCZ()的，他也要作为world里的一个节点被排序的 ok
*这里的storeCCZ()是用的第一个child的visu.getCCZ()
*
*注意这里面的东西是都放在一个mc里的，所以别的东西不能插进来
*
*这个的一个好处是减轻world.sortOnCCZ() 的压力
 * 
 * 728需要实现最下面的东西不参加排序 ok 不排序的东西在最底层，要最先加上！ 
 * 
 * 用dict_child只是为了方便删除
*/
package kgame5.k3d.core.obj3d.node3d {
import kgame5.k3d.core.obj3d.hardvo.HardVO;

public class Group3D extends Node3D{
	
	//_____________________Property_________________________
	
	protected var aChild:Array;
	
	//______________________Method__________________________
	//注意要想办法禁止这个的实例化
	public function Group3D(){
		super();
		
		aChild=new Array();
	}
	
	//##添加子
	public function addChild(md:Node3D):void{
		
		//1,如果有老的，先从老的里删除
		if(md.getParent()!=null){
			md.getParent().removeChild(md);
		}
		
		//2,设置parent
		md.setParent(this);
		
		//3,逻辑加入到child
		aChild.push(md);
		
		//4,更新边界
		this.updateAABB();
		
		//5,视图加入，这个要子类去做
	}
	
	//##删除
	public function removeChild(md:Node3D):void{
		
		//1,安全检查
		if(md==null){
			return;
		}
		if(containsChild(md)==false){
			return;
		}
		
		//2,逻辑删除.aChild里删除
		for(var i:int=aChild.length-1;i>=0;i--){
			if(aChild[i]==md){
				aChild.splice(i,1);
				break;
			}
		}
		
		//3,更新边界
		this.updateAABB();
			
		//4,mc删除,由子类去做

	}
	
	public function getChildAt(idx:int):Node3D{
		return aChild[idx];
	}
	
	public function containsChild(aim:Node3D):Boolean{
		for each(var md:Node3D in aChild){
			if(md==aim){
				return true;
			}
		}
		return false;
	}
	
	//真正销毁对象,释放内存
	override public function dispose():void{
		//T.p("Group3D.dispose");
		//1,从父中剔除
		var p:Group3D=this.getParent();
		if(p!=null){
			p.removeChild(this);
		}
		
		//更新边界
		//不用更新了，因为已经被销毁了啊
		//this.updateAABB();
		
		//2,自己释放掉持有的资源
		//!!这个而不需要。因为从咨询员树删除了就可以了。
		//removeAllChild();
	}
	
	//##去掉所有子
	public function removeAllChild():void{
		//逻辑
		aChild=new Array();
		
		//更新边界
		this.updateAABB();
		
		//视图
	}
	
	//这个是被外部遍历子用的,dict
	public function getChildren():Array{
		return aChild;
	}
	
	public function getChildCount():int{
		return aChild.length;
	}
	
	//--计算边界盒子,由子来计算
	protected function updateAABB():void{
		var 
			minA:Number=0,maxA:Number=0,
			minB:Number=0,maxB:Number=0,
			minH:Number=0,maxH:Number=0;
			
			
			for each(var md:Node3D in aChild){
				
				var hv:HardVO = md.ti.hardVO;
				
				//注意此中心是多边形的中心
				var x:Number = hv.v3d_p.x;
				var y:Number= hv.v3d_p.y;
				var z:Number= hv.v3d_p.z;
				
				var A2:Number = hv.aabb.A/2;
				var B2:Number = hv.aabb.B/2;
				var H2:Number = hv.aabb.H/2;
				
				
				minA=Math.min(minA,x-A2);
				minB=Math.min(minB,z-B2);
				minH=Math.min(minH,y-H2);
				
				maxA=Math.max(maxA,x+A2);
				maxB=Math.max(maxB,z+B2);
				maxH=Math.max(maxH,y+H2);
			}
		
		//--AABB
		ti.hardVO.aabb.A=maxA-minA;
		ti.hardVO.aabb.B=maxB-minB;
		ti.hardVO.aabb.H=maxH-minH;
		
		//--BBall
		ti.hardVO.bball.R= ti.hardVO.aabb.calcR();
		
		//-注意gi的aabb和bball和ti的hardVO的aabb和bball是一样的
	}
}//end of class
}
